﻿using ku.datamodel.contract;
using NUnit.Framework;

namespace ku.merger.tests
{
  [TestFixture]
  public class TestMerger
  {
    [Test]
    public void Wort_mit_folgendem_Satzzeichen_wird_gemerged()
    {
      var input = new[]
                    {
                      new Token("xdsfgdsf", TokenType.Wort), 
                      new Token(".", TokenType.Satzzeichen),
                    };

      var sut = new Merger();
      var result = sut.Merge(input);


      var expected = new[]
                    {
                      new Token("xdsfgdsf.", TokenType.Wort), 
                    };

      Assert.That(result, Is.EqualTo(expected));
    }

    [Test]
    public void Wort_mit_vorangegangenem_Satzzeichen_wird_nicht_gemerged()
    {
      var input = new[]
                    {
                      new Token(".", TokenType.Satzzeichen),
                      new Token("xdsfgdsf", TokenType.Wort), 
                    };

      var sut = new Merger();
      var result = sut.Merge(input);


      var expected = new[]
                    {
                      new Token(".", TokenType.Satzzeichen),
                      new Token("xdsfgdsf", TokenType.Wort), 
                    };

      Assert.That(result, Is.EqualTo(expected));
    }

    [Test]
    public void Zwei_Woerter_mit_Whitespace_werden_nicht_gemerged()
    {
      var input = new[]
                    {
                      new Token("x", TokenType.Wort), 
                      new Token("", TokenType.Whitespace),
                      new Token("yz", TokenType.Wort), 
                    };

      var sut = new Merger();
      var result = sut.Merge(input);


      var expected = new[]
                    {
                      new Token("x", TokenType.Wort), 
                      new Token("", TokenType.Whitespace),
                      new Token("yz", TokenType.Wort), 
                    };

      Assert.That(result, Is.EqualTo(expected));
    }

    [Test]
    public void Ein_Wort_mit_folgendem_Absatzende_wird_nicht_gemerged()
    {
      var input = new[]
                    {
                      new Token("a", TokenType.Wort), 
                      new Token("\n", TokenType.Absatzende),
                    };

      var sut = new Merger();
      var result = sut.Merge(input);


      var expected = new[]
                    {
                      new Token("a", TokenType.Wort), 
                      new Token("\n", TokenType.Absatzende),
                    };

      Assert.That(result, Is.EqualTo(expected));
    }

    [Test]
    public void Ein_Wort_mit_zwei_folgenden_Absatzenden_wird_nicht_gemerged()
    {
      var input = new[]
                    {
                      new Token("a", TokenType.Wort), 
                      new Token("\n", TokenType.Absatzende),
                      new Token("\n", TokenType.Absatzende),
                    };

      var sut = new Merger();
      var result = sut.Merge(input);


      var expected = new[]
                    {
                      new Token("a", TokenType.Wort), 
                      new Token("\n", TokenType.Absatzende),
                      new Token("\n", TokenType.Absatzende),
                    };

      Assert.That(result, Is.EqualTo(expected));
    }

    [Test]
    public void Ein_Wort_mit_folgenden_Whitespaces_wird_mit_auch_nicht_gemerged()
    {
      var input = new[]
                    {
                      new Token("silbe", TokenType.Wort), 
                      new Token("   ", TokenType.Whitespace),
                    };

      var sut = new Merger();
      var result = sut.Merge(input);


      var expected = new[]
                    {
                      new Token("silbe", TokenType.Wort), 
                      new Token("   ", TokenType.Whitespace),
                    };

      Assert.That(result, Is.EqualTo(expected));
    }

    [Test]
    public void Ein_Wort_mit_folgendem_Punkt_wird_gemerged()
    {
      var input = new[]
                    {
                      new Token("inhalt", TokenType.Wort), 
                      new Token(@".", TokenType.Satzzeichen),
                    };

      var sut = new Merger();
      var result = sut.Merge(input);


      var expected = new[]
                    {
                      new Token(@"inhalt.", TokenType.Wort), 
                    };

      Assert.That(result, Is.EqualTo(expected));
    }

    [Test]
    public void Ein_Wort_mit_folgendem_Ausrufezeichen_wird_gemerged()
    {
      var input = new[]
                    {
                      new Token("inhalt", TokenType.Wort), 
                      new Token(@"!", TokenType.Satzzeichen),
                    };

      var sut = new Merger();
      var result = sut.Merge(input);


      var expected = new[]
                    {
                      new Token(@"inhalt!", TokenType.Wort), 
                    };

      Assert.That(result, Is.EqualTo(expected));
    }

    [Test]
    public void Ein_Wort_mit_folgendem_Fragezeichen_wird_gemerged()
    {
      var input = new[]
                    {
                      new Token("inhalt", TokenType.Wort), 
                      new Token(@"?", TokenType.Satzzeichen),
                    };

      var sut = new Merger();
      var result = sut.Merge(input);


      var expected = new[]
                    {
                      new Token(@"inhalt?", TokenType.Wort), 
                    };

      Assert.That(result, Is.EqualTo(expected));
    }

    [Test]
    public void Ein_Wort_mit_folgendem_Komma_wird_gemerged()
    {
      var input = new[]
                    {
                      new Token("inhalt", TokenType.Wort), 
                      new Token(@",", TokenType.Satzzeichen),
                    };

      var sut = new Merger();
      var result = sut.Merge(input);


      var expected = new[]
                    {
                      new Token(@"inhalt,", TokenType.Wort), 
                    };

      Assert.That(result, Is.EqualTo(expected));
    }

    [Test]
    public void Mehrere_Wörter_mit_nachfolgenden_Satzzeichen_werden_gemerged()
    {
      var input = new[]
                    {
                      new Token(@",", TokenType.Satzzeichen),
                      new Token("inhalt1", TokenType.Wort), 
                      new Token(@",", TokenType.Satzzeichen),
                      new Token("inhalt2", TokenType.Wort), 
                      new Token(@".", TokenType.Satzzeichen),
                      new Token("inhalt3", TokenType.Wort), 
                      new Token(@"?", TokenType.Satzzeichen),
                      new Token("inhalt4", TokenType.Wort), 
                      new Token(@":", TokenType.Satzzeichen),
                      new Token("inhalt5", TokenType.Wort), 
                      new Token(@"!", TokenType.Satzzeichen),
                    };

      var sut = new Merger();
      var result = sut.Merge(input);


      var expected = new[]
                    {
                      new Token(@",", TokenType.Satzzeichen), 
                      new Token(@"inhalt1,", TokenType.Wort), 
                      new Token(@"inhalt2.", TokenType.Wort), 
                      new Token(@"inhalt3?", TokenType.Wort), 
                      new Token(@"inhalt4:", TokenType.Wort), 
                      new Token(@"inhalt5!", TokenType.Wort), 
                    };

      Assert.That(result, Is.EqualTo(expected));
    }


  }
}
